// utils/storage.js
// 数据存储工具类

import { STORAGE_KEYS } from './constants.js'

/**
 * 存储工具类
 */
class Storage {
  /**
   * 设置数据到本地存储
   * @param {string} key - 存储键名
   * @param {*} data - 要存储的数据
   * @returns {boolean} 是否成功
   */
  static setItem(key, data) {
    try {
      wx.setStorageSync(key, data)
      console.log(`存储数据成功: ${key}`)
      return true
    } catch (error) {
      console.error(`存储数据失败: ${key}`, error)
      return false
    }
  }

  /**
   * 从本地存储获取数据
   * @param {string} key - 存储键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 存储的数据或默认值
   */
  static getItem(key, defaultValue = null) {
    try {
      const data = wx.getStorageSync(key)
      return data !== '' ? data : defaultValue
    } catch (error) {
      console.error(`获取数据失败: ${key}`, error)
      return defaultValue
    }
  }

  /**
   * 删除本地存储数据
   * @param {string} key - 存储键名
   * @returns {boolean} 是否成功
   */
  static removeItem(key) {
    try {
      wx.removeStorageSync(key)
      console.log(`删除数据成功: ${key}`)
      return true
    } catch (error) {
      console.error(`删除数据失败: ${key}`, error)
      return false
    }
  }

  /**
   * 清空所有本地存储数据
   * @returns {boolean} 是否成功
   */
  static clear() {
    try {
      wx.clearStorageSync()
      console.log('清空所有数据成功')
      return true
    } catch (error) {
      console.error('清空所有数据失败', error)
      return false
    }
  }

  /**
   * 获取存储信息
   * @returns {Object} 存储信息
   */
  static getStorageInfo() {
    try {
      const info = wx.getStorageInfoSync()
      return {
        keys: info.keys,
        currentSize: info.currentSize,
        limitSize: info.limitSize
      }
    } catch (error) {
      console.error('获取存储信息失败', error)
      return null
    }
  }
}

/**
 * 任务数据存储管理类
 */
class TaskStorage {
  /**
   * 获取所有任务
   * @returns {Array} 任务列表
   */
  static getAllTasks() {
    const tasks = Storage.getItem(STORAGE_KEYS.TASKS, [])
    return Array.isArray(tasks) ? tasks : []
  }

  /**
   * 保存任务列表
   * @param {Array} tasks - 任务列表
   * @returns {boolean} 是否成功
   */
  static saveTasks(tasks) {
    if (!Array.isArray(tasks)) {
      console.error('保存任务失败: 数据格式不正确')
      return false
    }
    return Storage.setItem(STORAGE_KEYS.TASKS, tasks)
  }

  /**
   * 获取活跃任务（未删除的任务）
   * @returns {Array} 活跃任务列表
   */
  static getActiveTasks() {
    const allTasks = this.getAllTasks()
    return allTasks.filter(task => !task.isDeleted)
  }

  /**
   * 获取待完成任务
   * @returns {Array} 待完成任务列表
   */
  static getPendingTasks() {
    const activeTasks = this.getActiveTasks()
    return activeTasks.filter(task => task.status === 0) // TASK_STATUS.PENDING
  }

  /**
   * 获取已完成任务
   * @returns {Array} 已完成任务列表
   */
  static getCompletedTasks() {
    const activeTasks = this.getActiveTasks()
    return activeTasks.filter(task => task.status === 1) // TASK_STATUS.COMPLETED
  }

  /**
   * 根据ID获取任务
   * @param {string} taskId - 任务ID
   * @returns {Object|null} 任务对象或null
   */
  static getTaskById(taskId) {
    const allTasks = this.getAllTasks()
    return allTasks.find(task => task.id === taskId) || null
  }

  /**
   * 添加新任务
   * @param {Object} task - 任务对象
   * @returns {boolean} 是否成功
   */
  static addTask(task) {
    const allTasks = this.getAllTasks()
    allTasks.push(task)
    return this.saveTasks(allTasks)
  }

  /**
   * 更新任务
   * @param {string} taskId - 任务ID
   * @param {Object} updates - 更新的字段
   * @returns {boolean} 是否成功
   */
  static updateTask(taskId, updates) {
    const allTasks = this.getAllTasks()
    const taskIndex = allTasks.findIndex(task => task.id === taskId)
    
    if (taskIndex === -1) {
      console.error('更新任务失败: 任务不存在')
      return false
    }

    // 更新任务数据
    allTasks[taskIndex] = {
      ...allTasks[taskIndex],
      ...updates,
      updateTime: Date.now()
    }

    return this.saveTasks(allTasks)
  }

  /**
   * 删除任务（软删除）
   * @param {string} taskId - 任务ID
   * @returns {boolean} 是否成功
   */
  static deleteTask(taskId) {
    return this.updateTask(taskId, {
      isDeleted: true,
      updateTime: Date.now()
    })
  }

  /**
   * 完成任务
   * @param {string} taskId - 任务ID
   * @returns {boolean} 是否成功
   */
  static completeTask(taskId) {
    return this.updateTask(taskId, {
      status: 1, // TASK_STATUS.COMPLETED
      completeTime: Date.now()
    })
  }

  /**
   * 恢复任务为待完成状态
   * @param {string} taskId - 任务ID
   * @returns {boolean} 是否成功
   */
  static uncompleteTask(taskId) {
    return this.updateTask(taskId, {
      status: 0, // TASK_STATUS.PENDING
      completeTime: 0
    })
  }

  /**
   * 永久删除任务
   * @param {string} taskId - 任务ID
   * @returns {boolean} 是否成功
   */
  static permanentDeleteTask(taskId) {
    const allTasks = this.getAllTasks()
    const filteredTasks = allTasks.filter(task => task.id !== taskId)
    return this.saveTasks(filteredTasks)
  }

  /**
   * 清空所有任务
   * @returns {boolean} 是否成功
   */
  static clearAllTasks() {
    return this.saveTasks([])
  }

  /**
   * 获取任务统计信息
   * @returns {Object} 统计信息
   */
  static getTaskStats() {
    const activeTasks = this.getActiveTasks()
    const pendingTasks = this.getPendingTasks()
    const completedTasks = this.getCompletedTasks()

    return {
      total: activeTasks.length,
      pending: pendingTasks.length,
      completed: completedTasks.length,
      completionRate: activeTasks.length > 0 ? Math.round((completedTasks.length / activeTasks.length) * 100) : 0
    }
  }

  /**
   * 按优先级筛选任务
   * @param {Array} tasks - 任务列表
   * @param {string} priority - 优先级过滤器 ('all', 'high', 'medium', 'low')
   * @returns {Array} 筛选后的任务列表
   */
  static filterTasksByPriority(tasks, priority) {
    if (priority === 'all') {
      return tasks
    }

    const priorityMap = {
      'high': 1,
      'medium': 2,
      'low': 3
    }

    return tasks.filter(task => task.priority === priorityMap[priority])
  }

  /**
   * 按时间排序任务
   * @param {Array} tasks - 任务列表
   * @param {string} sortBy - 排序字段 ('createTime', 'updateTime', 'completeTime')
   * @param {string} order - 排序顺序 ('asc', 'desc')
   * @returns {Array} 排序后的任务列表
   */
  static sortTasks(tasks, sortBy = 'createTime', order = 'desc') {
    return [...tasks].sort((a, b) => {
      const aValue = a[sortBy] || 0
      const bValue = b[sortBy] || 0
      
      if (order === 'asc') {
        return aValue - bValue
      } else {
        return bValue - aValue
      }
    })
  }
}

export { Storage, TaskStorage } 